package goxpath

import (
	
	
	

	
)

//Marshal prints the result tree, r, in XML form to w.
func ( tree.Node,  io.Writer) error {
	return marshal(, )
}

//MarshalStr is like Marhal, but returns a string.
func ( tree.Node) (string, error) {
	 := bytes.NewBufferString("")
	 := marshal(, )

	return .String(), 
}

func marshal( tree.Node,  io.Writer) error {
	 := xml.NewEncoder()
	 := encTok(, )
	if  != nil {
		return 
	}

	return .Flush()
}

func encTok( tree.Node,  *xml.Encoder) error {
	switch .GetNodeType() {
	case tree.NtAttr:
		return encAttr(.GetToken().(xml.Attr), )
	case tree.NtElem:
		return encEle(.(tree.Elem), )
	case tree.NtNs:
		return encNS(.GetToken().(xml.Attr), )
	case tree.NtRoot:
		for ,  := range .(tree.Elem).GetChildren() {
			 := (, )
			if  != nil {
				return 
			}
		}
		return nil
	}

	//case tree.NtChd, tree.NtComm, tree.NtPi:
	return .EncodeToken(.GetToken())
}

func encAttr( xml.Attr,  *xml.Encoder) error {
	 := .Name.Local + `="` + .Value + `"`

	if .Name.Space != "" {
		 += ` xmlns="` + .Name.Space + `"`
	}

	 := xml.ProcInst{
		Target: "attribute",
		Inst:   ([]byte)(),
	}

	return .EncodeToken()
}

func encNS( xml.Attr,  *xml.Encoder) error {
	 := xml.ProcInst{
		Target: "namespace",
		Inst:   ([]byte)(.Value),
	}
	return .EncodeToken()
}

func encEle( tree.Elem,  *xml.Encoder) error {
	 := xml.StartElement{
		Name: .GetToken().(xml.StartElement).Name,
	}

	 := .GetAttrs()
	.Attr = make([]xml.Attr, len())
	for  := range  {
		.Attr[] = [].GetToken().(xml.Attr)
	}

	 := .EncodeToken()
	if  != nil {
		return 
	}

	if ,  := .(tree.Elem);  {
		for ,  := range .GetChildren() {
			 := encTok(, )
			if  != nil {
				return 
			}
		}
	}

	return .EncodeToken(.End())
}